home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / dev / ds5000.md / devSCSIC90.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  50KB  |  1,811 lines
  1. /* 
  2.  * devSCSIC90.c --
  3.  *
  4.  *    Routines specific to the SCSI NCR 53C9X Host Adaptor.  This adaptor is
  5.  *    based on the NCR 53C90 chip.
  6.  *    The 53C90 supports connect/dis-connect.
  7.  *
  8.  * Copyright 1988 Regents of the University of California
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  */
  17.  
  18. #ifndef lint
  19. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/dev/ds5000.md/devSCSIC90.c,v 1.10 92/07/13 17:47:33 mottsmth Exp $ SPRITE (Berkeley)";
  20. #endif /* not lint */
  21.  
  22. #include "sprite.h"
  23. #include "scsiC90.h"
  24. #include "mach.h"
  25. #include "dev.h"
  26. #include "scsiHBA.h"
  27. #include "scsiDevice.h"
  28. #include "sync.h"
  29. #include "stdio.h"
  30. #include "stdlib.h"
  31. #include "string.h"
  32. #include "bstring.h"
  33. #include "devSCSIC90.h"
  34. #include "devSCSIC90Int.h"
  35.  
  36. /*
  37.  * Forward declarations.  
  38.  */
  39.  
  40. static void        PrintMsg _ARGS_ ((unsigned int msg));
  41. static void        PrintPhase _ARGS_ ((unsigned int phase));
  42. static void        PrintLastPhase _ARGS_ ((unsigned int phase));
  43. static ReturnStatus     SendCommand _ARGS_ ((Device *devPtr,
  44.                                              ScsiCmd *scsiCmdPtr));
  45. static void             PrintRegs _ARGS_((volatile CtrlRegs *regsPtr));
  46. static void             PerformCmdDone _ARGS_((Controller *ctrlPtr,
  47.                            ReturnStatus status));
  48. static ReturnStatus     PerformSelect _ARGS_((Controller *ctrlPtr,
  49.                           unsigned int interruptReg,
  50.                           unsigned int sequenceReg));
  51. static ReturnStatus     PerformDataXfer _ARGS_((Controller *ctrlPtr,
  52.                           unsigned int interruptReg,
  53.                           unsigned int statusReg));
  54. static ReturnStatus     PerformStatus _ARGS_((Controller *ctrlPtr,
  55.                           unsigned int interruptReg));
  56. static ReturnStatus     PerformMsgIn _ARGS_(( Controller *ctrlPtr));
  57. static ReturnStatus     PerformReselect _ARGS_(( Controller *ctrlPtr,
  58.                           unsigned int interruptReg));
  59. static ReturnStatus     PerformExtendedMsgIn _ARGS_(( Controller *ctrlPtr,
  60.                           unsigned int message));
  61. static int              SpecialSenseProc _ARGS_((ScsiCmd *scsiCmdPtr,
  62.                         ReturnStatus status,
  63.                         int statusByte,
  64.                         int byteCount,
  65.                         int senseLength,
  66.                         Address senseDataPtr));
  67. static void             PutCircBuf _ARGS_((int type, char *object));
  68.  
  69. /*
  70.  * devSCSIC90Debug - debugging level
  71.  *    2 - normal level
  72.  *    4 - one print per command in the normal case
  73.  *    5 - traces interrupts
  74.  */
  75. int devSCSIC90Debug = 2;
  76. Controller *Controllers[MAX_SCSIC90_CTRLS];
  77.  
  78. char        circBuf[CIRCBUFLEN] = {""};
  79. int         circHead = 0;
  80. char numTab[16] = {
  81.     '0', '1', '2', '3', '4', '5', '6', '7',
  82.     '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
  83.     };
  84.      
  85.  
  86.  
  87. /*
  88.  *----------------------------------------------------------------------
  89.  *
  90.  * SendCommand --
  91.  *
  92.  *      Send a command to a SCSI controller.
  93.  *    NOTE: The caller is assumed to have the master lock of the controller
  94.  *    to which the device is attached held.
  95.  *      
  96.  *
  97.  * Results:
  98.  *    An error code.
  99.  *
  100.  * Side effects:
  101.  *    Those of the command (Read, write etc.)
  102.  *
  103.  *----------------------------------------------------------------------
  104.  */
  105. static ReturnStatus
  106. SendCommand(devPtr, scsiCmdPtr)
  107.     Device     *devPtr;        /* Device to sent to. */
  108.     ScsiCmd    *scsiCmdPtr;        /* Command to send. */
  109. {
  110.     volatile CtrlRegs    *regsPtr; /* Host Adaptor registers */
  111.     char    *charPtr;
  112.     Controller    *ctrlPtr;
  113.     int i;
  114.     int size;                /* Number of bytes to transfer */
  115.  
  116.     /*
  117.      * Set current active device and command for this controller.
  118.      */
  119.     ctrlPtr = devPtr->ctrlPtr;
  120.     regsPtr = ctrlPtr->regsPtr;
  121.  
  122.     if (ctrlPtr->devPtr != (Device *)NIL) {
  123.     panic("SCSIC90Command: can't send: host is busy\n");
  124.     }
  125.  
  126.     SET_CTRL_BUSY(ctrlPtr,devPtr);
  127.     SET_DEV_BUSY(devPtr, scsiCmdPtr);
  128.  
  129.     devPtr->scsiCmdPtr   = scsiCmdPtr;
  130.     size = scsiCmdPtr->bufferLen;
  131.     if (size == 0) {
  132.     devPtr->dmaState = DMA_INACTIVE;
  133.     } else {
  134.     devPtr->dmaState = (scsiCmdPtr->dataToDevice) ? DMA_SEND :
  135.                             DMA_RECEIVE;
  136.     }
  137.  
  138.     PUTCIRCBUF(CSTR, "send: targ ");
  139.     PUTCIRCBUF(CBYTE, (char *)devPtr->targetID);
  140.     PUTCIRCBUF(CSTR, ";cmd ");
  141.     PUTCIRCBUF(CINT, (char *)scsiCmdPtr);
  142.     PUTCIRCBUF(CSTR,";buf ");
  143.     PUTCIRCBUF(CINT, (char *)scsiCmdPtr->buffer);
  144.     PUTCIRCBUF(CSTR, ";len ");
  145.     PUTCIRCBUF(CINT, (char *)size);
  146.     PUTCIRCBUF(CSTR,";op ");
  147.     PUTCIRCBUF(CBYTE, (char *)scsiCmdPtr->commandBlock[0]);
  148.     PUTCIRCNULL;
  149.  
  150.     /*
  151.      * SCSI SELECTION.
  152.      */
  153.  
  154.     /*
  155.      * Set phase to selection and command phase so that we know what's happened
  156.      * in the next phase.
  157.      */
  158.     devPtr->lastPhase = PHASE_SELECTION;    /* Selection & command phase.*/
  159.     devPtr->commandStatus = 0;            /* No status yet. */
  160.     devPtr->activeBufPtr = scsiCmdPtr->buffer;
  161.     devPtr->activeBufLen = scsiCmdPtr->bufferLen;
  162.     /* Load select/reselect bus ID register with target ID. */
  163.     regsPtr->scsi_ctrl.write.destID = devPtr->targetID;
  164.     /* Load select/reselect timeout period. */
  165.     regsPtr->scsi_ctrl.write.timeout = SELECT_TIMEOUT;
  166.     /* Zero value for asynchronous transfer. */
  167.     regsPtr->scsi_ctrl.write.synchOffset = devPtr->synchOffset;
  168.     if (devPtr->synchOffset != 0) {
  169.     regsPtr->scsi_ctrl.write.synchPer = devPtr->synchPeriod;
  170.     }
  171.     /* Set the clock conversion register. */
  172.     regsPtr->scsi_ctrl.write.clockConv = CLOCKCONV;
  173.  
  174.     EMPTY_BUFFER();
  175.  
  176.     /* 
  177.      * There are 3 selection possibilities:
  178.      * 1) Without Attention (NATN) which says we don't do disconnect/reselect.
  179.      *    No need to use this anymore.
  180.      * 2) With Attention (ATN) which goes through arbitration, selection
  181.      *    and command phases, announcing that we do disconnect/reselect.
  182.      *    The usual mode.
  183.      * 3) With attention and stop (ATNS) which just goes through 
  184.      *    arbitration and selection phases and stops.  This gives
  185.      *    us a chance to send another message after the IDENTIFY msg
  186.      *    before sending the command.  For use in sending the 1st
  187.      *    message of the synchronous data xfer negotiation.
  188.      */
  189.  
  190.     if (scsiCmdPtr->commandBlockLen != 6 &&
  191.     scsiCmdPtr->commandBlockLen != 10 &&
  192.     scsiCmdPtr->commandBlockLen != 12) {
  193.     printf("%s: Command is wrong length.\n");
  194.     PUTCIRCBUF(CSTR,"send: bad cmd len\n");
  195.     PUTCIRCNULL;
  196.     return DEV_INVALID_ARG;     /* Is this the correct error? */
  197.     }
  198.  
  199.  
  200.     regsPtr->scsi_ctrl.write.FIFO = SCSI_DIS_REC_IDENTIFY | devPtr->handle.LUN;
  201.  
  202.     if ((devPtr->synchPeriod < MIN_SYNCH_PERIOD) &&
  203.     (devPtr->msgFlag & ENABLEEXTENDEDMSG)) {
  204.     devPtr->msgFlag |= REQEXTENDEDMSG;
  205.     EMPTY_BUFFER();
  206.     regsPtr->scsi_ctrl.write.command = CR_SLCT_ATNS;
  207.     PUTCIRCBUF(CSTR,"send ATNS; per ");
  208.     } else {
  209.     /* Load FIFO with 6, 10, or 12 byte scsi command. */
  210.     charPtr = scsiCmdPtr->commandBlock;
  211.     for (i = 0; i < scsiCmdPtr->commandBlockLen; i++) {
  212.         regsPtr->scsi_ctrl.write.FIFO = *charPtr;
  213.         charPtr++;
  214.     }
  215.     PUTCIRCBUF(CSTR,"send ATN; per ");
  216.     EMPTY_BUFFER();
  217.     regsPtr->scsi_ctrl.write.command = CR_SLCT_ATN;
  218.     }
  219.     PUTCIRCBUF(CBYTE,(char *)(devPtr->synchPeriod));
  220.     PUTCIRCBUF(CSTR,"; off ");
  221.     PUTCIRCBUF(CBYTE,(char *)(devPtr->synchOffset));
  222.     PUTCIRCBUF(CSTR,"; cmd ");
  223.     PUTCIRCBUF(CBYTE,(char *)(*scsiCmdPtr->commandBlock));
  224.     PUTCIRCNULL;
  225.  
  226.     return SUCCESS;
  227. }
  228.  
  229.  
  230. /*
  231.  *----------------------------------------------------------------------
  232.  *
  233.  * RequestDone --
  234.  *
  235.  *    Process a request that has finished. Unless a SCSI check condition
  236.  *    bit is present in the status returned, the request call back
  237.  *    function is called.  If check condition is set we fire off a
  238.  *    SCSI REQUEST SENSE to get the error sense bytes from the device.
  239.  *
  240.  * Results:
  241.  *    None.
  242.  *
  243.  * Side effects:
  244.  *    The call back function may be called.
  245.  *
  246.  *----------------------------------------------------------------------
  247.  */
  248.  
  249. static void
  250. RequestDone(devPtr,scsiCmdPtr,status,scsiStatusByte,amountTransferred)
  251.     Device    *devPtr;    /* Device for request. */
  252.     ScsiCmd    *scsiCmdPtr;    /* Request that finished. */
  253.     ReturnStatus status;    /* Status returned. */
  254.     unsigned char scsiStatusByte;    /* SCSI Status Byte. */
  255.     int        amountTransferred; /* Amount transferred by command. */
  256. {
  257.     ReturnStatus    senseStatus;
  258.     Controller            *ctrlPtr = devPtr->ctrlPtr;
  259.     int i;
  260.  
  261.     PUTCIRCBUF(CSTR,"done: targ ");
  262.     PUTCIRCBUF(CBYTE, (char *)devPtr->targetID);
  263.     PUTCIRCBUF(CSTR,";rc ");
  264.     PUTCIRCBUF(CBYTE, (char *)status);
  265.     PUTCIRCBUF(CSTR,";stat ");
  266.     PUTCIRCBUF(CBYTE, (char *)scsiStatusByte);
  267.     PUTCIRCBUF(CSTR,";cnt ");
  268.     PUTCIRCBUF(CBYTE, (char *)amountTransferred);
  269.     PUTCIRCNULL;
  270.  
  271.     SET_CTRL_FREE(ctrlPtr);
  272.  
  273.     /*
  274.      * First check to see if this is the reponse of a HBA-driver generated 
  275.      * REQUEST SENSE command.  If this is the case, we can process
  276.      * the callback of the frozen command for this device and
  277.      * allow the flow of command to the device to be resummed.
  278.      */
  279.     if (scsiCmdPtr->doneProc == SpecialSenseProc) {
  280.     PUTCIRCBUF(CSTR,"sense data:");
  281.     for (i=0; i<amountTransferred; i++) {
  282.         circBuf[circHead] = ' ';
  283.         circHead = (circHead + 1) % CIRCBUFLEN;
  284.         PUTCIRCBUF(CBYTE, (char *)(devPtr->senseBuffer[i]));
  285.     }
  286.     PUTCIRCNULL;
  287.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  288.     (devPtr->frozen.scsiCmdPtr->doneProc)(devPtr->frozen.scsiCmdPtr, 
  289.         SUCCESS,
  290.         devPtr->frozen.statusByte, 
  291.         devPtr->frozen.amountTransferred,
  292.         amountTransferred,
  293.         devPtr->senseBuffer);
  294.          MASTER_LOCK(&(ctrlPtr->mutex));
  295.      SET_DEV_FREE(devPtr);
  296.      return;
  297.     }
  298.     /*
  299.      * This must be an outside request finishing. If the request 
  300.      * suffered an error or the HBA or the scsi status byte
  301.      * says there is no error sense present, we can do the
  302.      * callback and free the controller.
  303.      */
  304.     if ((status != SUCCESS) ||
  305.     (scsiStatusByte != SCSI_STATUS_CHECK)) { 
  306.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  307.     PUTCIRCBUF(CSTR,"done: callback before...");
  308.     (scsiCmdPtr->doneProc)(scsiCmdPtr, status, scsiStatusByte,
  309.                    amountTransferred, 0, (char *) 0);
  310.     MASTER_LOCK(&(ctrlPtr->mutex));
  311.     PUTCIRCBUF(CSTR,"after");
  312.     PUTCIRCNULL;
  313.     SET_DEV_FREE(devPtr);
  314.     return;
  315.     } 
  316.     /*
  317.      * If we got here than the SCSI command came back from the device
  318.      * with the CHECK bit set in the status byte.
  319.      * Need to perform a REQUEST SENSE.  Move the current request 
  320.      * into the frozen state and issue a REQUEST SENSE. 
  321.      */
  322.  
  323.     PUTCIRCBUF(CSTR,"done: issue sense");
  324.     PUTCIRCNULL;
  325.     devPtr->synchPeriod = 0;
  326.     devPtr->synchOffset = 0;
  327.     devPtr->frozen.scsiCmdPtr = scsiCmdPtr;
  328.     devPtr->frozen.statusByte = scsiStatusByte;
  329.     devPtr->frozen.amountTransferred = amountTransferred;
  330.     DevScsiSenseCmd((ScsiDevice *)devPtr, DEV_MAX_SENSE_BYTES, 
  331.             devPtr->senseBuffer, &(devPtr->SenseCmd));
  332.     devPtr->SenseCmd.doneProc = SpecialSenseProc;
  333.     senseStatus = SendCommand(devPtr, &(devPtr->SenseCmd));
  334.     
  335.    /*
  336.      * If we got an HBA error on the REQUEST SENSE we end the outside 
  337.      * command with the SUCCESS status but zero sense bytes returned.
  338.      */
  339.     if (senseStatus != SUCCESS) {
  340.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  341.     (scsiCmdPtr->doneProc)(scsiCmdPtr, status, scsiStatusByte,
  342.                    amountTransferred, 0, (char *) 0);
  343.         MASTER_LOCK(&(ctrlPtr->mutex));
  344.     SET_DEV_FREE(devPtr);
  345.     }
  346.  
  347. }
  348.  
  349. /*
  350.  *----------------------------------------------------------------------
  351.  *
  352.  * DevEntryAvailProc --
  353.  *
  354.  *    Act upon an entry becomming available in the queue for this
  355.  *    controller. This routine is the Dev_Queue callback function that
  356.  *    is called whenever work becomes available for this controller. 
  357.  *    If the controller is not already busy we dequeue and start the
  358.  *    request.
  359.  *    NOTE: This routine is also called from DevSCSIC90Intr to start the
  360.  *    next request after the previously one finishes.
  361.  *
  362.  * Results:
  363.  *    None.
  364.  *
  365.  * Side effects:
  366.  *    Request may be dequeue and submitted to the device. Request callback
  367.  *    function may be called.
  368.  *
  369.  *----------------------------------------------------------------------
  370.  */
  371.  
  372. Boolean
  373. DevEntryAvailProc(clientData, newRequestPtr) 
  374.    ClientData    clientData;    /* Really the Device this request ready. */
  375.    List_Links *newRequestPtr;    /* The new SCSI request. */
  376. {
  377.     Device        *devPtr; 
  378.     Controller         *ctrlPtr;
  379.     ScsiCmd        *scsiCmdPtr = (ScsiCmd *)newRequestPtr;
  380.     ReturnStatus    status;
  381.  
  382.     devPtr = (Device *) clientData;
  383.     ctrlPtr = devPtr->ctrlPtr;
  384.     /*
  385.      * If we are busy (have an active request) just return. Otherwise 
  386.      * start the request.
  387.      */
  388.     
  389.     if ((IS_CTRL_FREE(ctrlPtr)) &&  (IS_DEV_FREE(devPtr))) {
  390.     PUTCIRCBUF(CSTR,"EAP: exec targ ");
  391.     PUTCIRCBUF(CBYTE, (char *)(devPtr->targetID));
  392.     PUTCIRCBUF(CSTR,"; mask ");
  393.     PUTCIRCBUF(CBYTE, (char *)(ctrlPtr->devQueuesMask));
  394.     PUTCIRCBUF(CSTR,"; cmd ptr ");
  395.     PUTCIRCBUF(CINT, (char *)newRequestPtr);
  396.     PUTCIRCNULL;
  397.     } else {
  398.     PUTCIRCBUF(CSTR,"EAP: NQ targ ");
  399.     PUTCIRCBUF(CBYTE, (char *)(devPtr->targetID));
  400.     PUTCIRCBUF(CSTR,"; mask ");
  401.     PUTCIRCBUF(CBYTE, (char *)(ctrlPtr->devQueuesMask));
  402.     PUTCIRCBUF(CSTR,"; cmd ptr ");
  403.     PUTCIRCBUF(CINT,(char *)newRequestPtr);
  404.     PUTCIRCBUF(CSTR,"; intDev ");
  405.     PUTCIRCBUF(CINT,(char *)(ctrlPtr->interruptDevPtr));
  406.     if (ctrlPtr->interruptDevPtr != (Device *)NIL) {
  407.         PUTCIRCBUF(CSTR,"; intDevCmd ");
  408.         PUTCIRCBUF(CINT,(char *)(ctrlPtr->interruptDevPtr->scsiCmdPtr));
  409.     }
  410.     PUTCIRCNULL;
  411.     return FALSE;
  412.     }
  413.  
  414. again:
  415.     scsiCmdPtr = (ScsiCmd *) newRequestPtr;
  416.     devPtr = (Device *) clientData;
  417.     status = SendCommand(devPtr, scsiCmdPtr);
  418.  
  419.     /*    
  420.      * If the command couldn't be started do the callback function.
  421.      */
  422.     if (status != SUCCESS) {
  423.      PUTCIRCBUF(CSTR,"eap: send fail");
  424.      PUTCIRCNULL;
  425.      RequestDone(devPtr,scsiCmdPtr,status,0,0);
  426.      newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  427.                          ctrlPtr->devQueuesMask,
  428.                          &clientData);
  429.     if (newRequestPtr != (List_Links *) NIL) { 
  430.         PUTCIRCBUF(CSTR,"eap: no cmd");
  431.         PUTCIRCNULL;
  432.         goto again;
  433.     } else {
  434.         PUTCIRCBUF(CSTR,"eap: cmd");
  435.         PUTCIRCBUF(CINT,(char *)newRequestPtr);
  436.         PUTCIRCNULL;
  437.     }
  438.     }
  439.  
  440.     return TRUE;
  441.  
  442. }   
  443.  
  444.  
  445. /*
  446.  *----------------------------------------------------------------------
  447.  *
  448.  * DevSCSIC90Intr --
  449.  *
  450.  * Handle interrupts from the SCSI controller.
  451.  *
  452.  * Results:
  453.  *    TRUE if an SCSIC90 controller was responsible for the interrupt
  454.  *    and this routine handled it.
  455.  *
  456.  * Side effects:
  457.  *    Usually a process is notified that an I/O has completed.
  458.  *      Extreme headaches from trying to follow this absurd code.
  459.  * 
  460.  * Note:
  461.  *      Cannot use printf for debugging in this routine since 
  462.  *      printf re-enables interrupts.
  463.  *
  464.  *----------------------------------------------------------------------
  465.  */
  466. Boolean 
  467. DevSCSIC90Intr(clientDataArg)
  468.     ClientData    clientDataArg;
  469. {
  470.     Controller        *ctrlPtr;
  471.     volatile CtrlRegs    *regsPtr;
  472.     Device        *devPtr;
  473.     unsigned char    phase;
  474.     ReturnStatus    status = SUCCESS;
  475.     unsigned char    interruptReg;
  476.     unsigned char    statusReg;
  477.     unsigned char    sequenceReg;
  478.     int                 i;
  479.     char            *charPtr;
  480.     char            tempChar;
  481.  
  482.     ctrlPtr = (Controller *) clientDataArg;
  483.     regsPtr = ctrlPtr->regsPtr;
  484.     devPtr = ctrlPtr->devPtr;
  485.  
  486.     MASTER_LOCK(&(ctrlPtr->mutex));
  487.  
  488.     /* Read registers.
  489.      * reading the interrupt register clears the status and sequence
  490.      * registers so it must be read last.
  491.      */
  492.     statusReg = regsPtr->scsi_ctrl.read.status;
  493.     sequenceReg = regsPtr->scsi_ctrl.read.sequence;
  494.     interruptReg = regsPtr->scsi_ctrl.read.interrupt;
  495.     phase = statusReg & SR_PHASE;
  496.     sequenceReg &= SEQ_MASK;
  497.  
  498.     PUTCIRCBUF(CSTR,"intr: dev ");
  499.     PUTCIRCBUF(CINT,(char *)devPtr);
  500.     PUTCIRCBUF(CSTR,";int ");
  501.     PUTCIRCBUF(CBYTE, (char *)interruptReg);
  502.     PUTCIRCBUF(CSTR,";stat ");
  503.     PUTCIRCBUF(CBYTE, (char *)statusReg);
  504.     PUTCIRCBUF(CSTR,";seq ");
  505.     PUTCIRCBUF(CBYTE, (char *)sequenceReg);
  506.     if (devPtr != (Device *)NIL) {
  507.     PUTCIRCBUF(CSTR,";last ");
  508.     PUTCIRCBUF(CBYTE, (char *)devPtr->lastPhase);
  509.     }
  510.     PUTCIRCNULL;
  511.  
  512. /*    printf("interruptReg 0x%02x, statusReg 0x%02x, sequenceReg 0x%02x\n",
  513.         interruptReg, statusReg, sequenceReg);
  514. */
  515.     /* Check for errors. */
  516.     if (statusReg & SR_GE) {
  517.     panic("gross error 1\n");
  518.     printf("%s: some gross error happened.\n",
  519.         devPtr->handle.locationName);
  520.     status = FAILURE;
  521.     }
  522.     if (statusReg & SR_PE) {
  523.     printf("%s: a parity error happened.\n",
  524.         devPtr->handle.locationName);
  525.     status = FAILURE;
  526.     }
  527.  
  528.     if (interruptReg & IR_SCSI_RST) {
  529.     printf("%s: SCSI reset detected.\n",
  530.         devPtr->handle.locationName);
  531.     status = FAILURE;
  532.     }
  533.     if (interruptReg & IR_ILL_CMD) {
  534.     if (ctrlPtr->interruptDevPtr != (Device *)NIL) {
  535.         PUTCIRCBUF(CSTR,"ignoring illegal cmd interrupt");
  536.         PUTCIRCNULL;
  537.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  538.         return TRUE;
  539.     } else {
  540.         printf("%s: illegal command.\n",
  541.            devPtr->handle.locationName);
  542.         status = FAILURE;
  543.     }
  544.     }
  545.     if (interruptReg & IR_SLCT_ATN) {
  546.     printf("%s: scsi controller selected with ATN which we don't allow.\n",
  547.         devPtr->handle.locationName);
  548.     status = FAILURE;
  549.     }
  550.     if (interruptReg & IR_SLCT) {
  551.     printf("%s: scsi controller selected as target which we don't allow.\n",
  552.         devPtr->handle.locationName);
  553.     status = FAILURE;
  554.     }
  555.     if (interruptReg & IR_RESLCT) {
  556.     PerformReselect(ctrlPtr, interruptReg);
  557.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  558.     return TRUE;
  559.     }
  560.     if (IS_CTRL_FREE(ctrlPtr)) {
  561.     if (status == SUCCESS)
  562.         panic("SCSIC90: Got interrupt but ctrl is free.\n");
  563.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  564.     return TRUE;
  565.     }
  566.  
  567.  
  568.     /* Where did we come from? */
  569.     switch (devPtr->lastPhase) {
  570.     case PHASE_COMMAND:
  571.     break;
  572.     case PHASE_BUS_FREE:
  573.     /* nothing happening yet. */
  574.     break;
  575.     case PHASE_SELECTION:
  576.     status = PerformSelect(ctrlPtr, interruptReg, sequenceReg);
  577.     break;
  578.     case PHASE_DATA_IN:
  579. #ifdef sun4c
  580.     /* Drain remaining bytes in pack register to memory. */
  581.     dmaRegsPtr->ctrl |= DMA_DRAIN;
  582. #endif
  583.     status = PerformDataXfer(ctrlPtr, interruptReg, statusReg);
  584.     break;
  585.     case PHASE_DATA_OUT:
  586.     status = PerformDataXfer(ctrlPtr, interruptReg, statusReg);
  587.     break;
  588.     case PHASE_STATUS:
  589.     status = PerformStatus(ctrlPtr, interruptReg);
  590.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  591.     return TRUE;
  592.     break;
  593.     case PHASE_MSG_OUT:
  594.     break;
  595.     case PHASE_MSG_IN:
  596.     status = PerformMsgIn(ctrlPtr);
  597.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  598.     return TRUE;
  599.     break;
  600.     case PHASE_STAT_MSG_IN:
  601.     if (!(interruptReg & IR_DISCNCT)) {
  602.         printf("SCSIC90: Should have seen end of I/O.\n");
  603.         status = FAILURE;
  604.     }
  605.     break;
  606.     case PHASE_RDY_DISCON:
  607.     if (interruptReg & IR_DISCNCT) {
  608.         PUTCIRCBUF(CSTR,"intr: targ ");
  609.         PUTCIRCBUF(CBYTE, (char *)devPtr->targetID);
  610.         PUTCIRCBUF(CSTR," discon.");
  611.         PUTCIRCNULL;
  612.         devPtr->lastPhase = PHASE_BUS_FREE;
  613.         SET_CTRL_FREE(ctrlPtr);
  614.         PerformCmdDone(ctrlPtr,status);
  615.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  616.         return TRUE;
  617.     } else {
  618.         printf("SCSIC90: expecting disconnect signal.\n");
  619.         status = FAILURE;
  620.     }
  621.     break;
  622.     default:
  623.     /* We set this field, so this shouldn't happen. */
  624.     printf("SCSIC90Intr: We came from an unknown phase.\n");
  625.     status = FAILURE;
  626.     break;
  627.     }
  628.  
  629.     if ((status != SUCCESS) || (interruptReg & IR_DISCNCT)) {
  630.         PUTCIRCBUF(CSTR,"intr: exit stat ");
  631.         PUTCIRCBUF(CBYTE,(char *)status);
  632.         PUTCIRCNULL;
  633.     RequestDone(devPtr,
  634.             devPtr->scsiCmdPtr,
  635.             status,
  636.             devPtr->commandStatus,
  637.             devPtr->scsiCmdPtr->bufferLen - devPtr->activeBufLen);
  638.     PerformCmdDone(ctrlPtr,status);
  639.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  640.     return TRUE;
  641.     }
  642.  
  643.     switch (phase) {
  644.  
  645.     case SR_DATA_OUT:
  646.     case SR_DATA_IN:
  647.     devPtr->lastPhase = (phase == SR_DATA_OUT ? PHASE_DATA_OUT :
  648.                  PHASE_DATA_IN);
  649.     /*
  650.      * It should be possible to do multiple blocks of DMA without
  651.      * returning to the higher level, if we set the max transfer size
  652.      * larger, but we don't handle that yet. XXX
  653.      */
  654. #ifdef sun4c
  655.     dmaControllerActive++;    /* Resetting controller not allowed. */
  656. #endif
  657.     PUTCIRCBUF(CSTR,"start dma ptr: ");
  658.     PUTCIRCBUF(CINT,(char *)devPtr->activeBufPtr);
  659.     PUTCIRCBUF(CSTR,"; len: ");
  660.     PUTCIRCBUF(CINT,(char *)devPtr->activeBufLen);
  661.     PUTCIRCNULL;
  662.     DevStartDMA(ctrlPtr);
  663.     break;
  664.     case SR_COMMAND:
  665.     charPtr = devPtr->scsiCmdPtr->commandBlock;
  666.     PUTCIRCBUF(CSTR,"cmd:");
  667.     for (i = 0; i < devPtr->scsiCmdPtr->commandBlockLen; i++) {
  668.         circBuf[circHead] = ' ';
  669.         circHead = (circHead + 1) % CIRCBUFLEN;
  670.         PUTCIRCBUF(CBYTE, (char *)*charPtr);
  671.         regsPtr->scsi_ctrl.write.FIFO = *charPtr;
  672.         charPtr++;
  673.     }
  674.     PUTCIRCNULL;
  675.     devPtr->lastPhase = PHASE_COMMAND;
  676.     regsPtr->scsi_ctrl.write.synchPer = devPtr->synchPeriod;
  677.     regsPtr->scsi_ctrl.write.synchOffset = devPtr->synchOffset;
  678.     regsPtr->scsi_ctrl.write.command = CR_XFER_INFO;
  679.     break;
  680.     case SR_STATUS:
  681.     /*
  682.      * We're in status phase.  If all goes right, the next interrupt
  683.      * will be after we've handled the message phase as well, although
  684.      * the phase will say we're in message phase.
  685.      */
  686.     devPtr->lastPhase = PHASE_STATUS;
  687.     regsPtr->scsi_ctrl.write.command = CR_INIT_COMP;
  688.     break;
  689.     case SR_MSG_OUT:
  690.     i = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  691.     if (i > 0) {
  692.         PUTCIRCBUF(CSTR,"msg-out: fifo: ");
  693.         while (i-- > 0) {
  694.         circBuf[circHead] = ' ';
  695.         circHead = (circHead + 1) % CIRCBUFLEN;
  696.         tempChar = regsPtr->scsi_ctrl.read.FIFO;
  697.         PUTCIRCBUF(CBYTE,(char*)(tempChar));
  698.         }
  699.         PUTCIRCNULL;
  700.     }
  701.     PUTCIRCBUF(CSTR,"msg-out: msg: ");
  702.     for (i=0; i<devPtr->messageBufLen; i++) {
  703.         circBuf[circHead] = ' ';
  704.         circHead = (circHead + 1) % CIRCBUFLEN;
  705.         PUTCIRCBUF(CBYTE, (char *)devPtr->messageBuf[i]);
  706.         regsPtr->scsi_ctrl.write.FIFO = devPtr->messageBuf[i];
  707.         devPtr->messageBuf[i] = '\0';
  708.     }
  709.     PUTCIRCNULL;
  710.     regsPtr->scsi_ctrl.write.command = CR_XFER_INFO;
  711.     devPtr->lastPhase = PHASE_MSG_OUT;
  712.     devPtr->messageBufLen = 0;
  713.     status = regsPtr->scsi_ctrl.read.status;
  714.     if (status & SR_GE) {
  715.         panic("gross error 2");
  716.     }
  717.     break;
  718.     case SR_MSG_IN:
  719.     /* request incoming message xfer */
  720.     regsPtr->scsi_ctrl.write.command = CR_XFER_INFO;
  721.     devPtr->lastPhase = PHASE_MSG_IN;
  722.     break;
  723.     default:
  724.     printf("unknown scsi phase type: 0x%02x\n", (int)phase);
  725.     status = FAILURE;
  726.     break;
  727.     }
  728.  
  729.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  730.     return TRUE;
  731. }
  732.  
  733. /*
  734.  *----------------------------------------------------------------------
  735.  *
  736.  * PerformCmdDone
  737.  *
  738.  *    Do cleanup after final phase of command.
  739.  *
  740.  * Results:
  741.  *    None.
  742.  *
  743.  * Side effects:
  744.  *    Calls RequestDone routine to invoke callback
  745.  *      and then gets next item of queue set.
  746.  *
  747.  *----------------------------------------------------------------------
  748.  */
  749. /*ARGSUSED*/
  750. static void
  751. PerformCmdDone(ctrlPtr,status)
  752.     Controller   *ctrlPtr;
  753.     ReturnStatus status;
  754. {
  755.     List_Links        *newRequestPtr;
  756.     ClientData        clientData;
  757.  
  758.     ctrlPtr->regsPtr->scsi_ctrl.write.command = CR_EN_SLCT;
  759.     if (IS_CTRL_FREE(ctrlPtr)) {
  760.     if (ctrlPtr->interruptDevPtr == (Device *)NIL) {
  761.         newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  762.                         ctrlPtr->devQueuesMask,
  763.                         &clientData);
  764.         PUTCIRCBUF(CSTR,"cdone: cmd ");
  765.         PUTCIRCBUF(CINT,(char *)newRequestPtr);
  766.         PUTCIRCNULL;
  767.     } else {
  768.         clientData = (ClientData)(ctrlPtr->interruptDevPtr);
  769.         newRequestPtr=(List_Links *)(ctrlPtr->interruptDevPtr->scsiCmdPtr);
  770.         SET_DEV_FREE(ctrlPtr->interruptDevPtr);
  771.         ctrlPtr->interruptDevPtr = (Device *)NIL;
  772.         PUTCIRCBUF(CSTR,"cdone: resend dev ");
  773.         PUTCIRCBUF(CINT, (char *)clientData);
  774.         PUTCIRCBUF(CSTR," cmd ");
  775.         PUTCIRCBUF(CINT,(char *)newRequestPtr);
  776.         PUTCIRCNULL;
  777.     }
  778.     if (newRequestPtr != (List_Links *) NIL) {
  779.         (void) DevEntryAvailProc(clientData, newRequestPtr);
  780.     }
  781.     } else {
  782.     PUTCIRCBUF(CSTR,"cdone: busy ");
  783.     PUTCIRCNULL;
  784.     }
  785.  
  786. }
  787.  
  788. /*
  789.  *----------------------------------------------------------------------
  790.  *
  791.  * PerformSelect
  792.  *
  793.  *    Interpret select phase
  794.  *
  795.  * Results:
  796.  *    None.
  797.  *
  798.  * Side effects:
  799.  *    None.
  800.  *
  801.  *----------------------------------------------------------------------
  802.  */
  803. static ReturnStatus
  804. PerformSelect(ctrlPtr, interruptReg, sequenceReg)
  805. Controller      *ctrlPtr;
  806. unsigned int    interruptReg;
  807. unsigned int    sequenceReg;
  808. {
  809.     Device   *devPtr = ctrlPtr->devPtr;
  810.     static char *errMsg[] = {
  811.     "No error",
  812.     "target timed out",
  813.     "no message-out phase",
  814.     "no command phase",
  815.     "command phase incomplete",
  816.     "unknown sequence error"
  817.     };
  818.     int msgNum;
  819.     ReturnStatus status = SUCCESS;
  820.  
  821.     switch(sequenceReg) {
  822.     case SEQ_COMPLETE:
  823.     msgNum = 0;
  824.     break;
  825.     case SEQ_NO_SEL:
  826.     if (interruptReg & IR_DISCNCT) {
  827.         msgNum = 1;
  828.         status = DEV_NO_DEVICE;
  829.     } else if (!(devPtr->msgFlag & REQEXTENDEDMSG)) {
  830.         msgNum = 2;
  831.     } else {
  832.         msgNum = 0;
  833.         devPtr->msgFlag &= ~REQEXTENDEDMSG;
  834.         devPtr->messageBuf[0] = SCSI_EXTENDED_MESSAGE;
  835.         devPtr->messageBuf[1] = 3;
  836.         devPtr->messageBuf[2] = SCSI_EXTENDED_MSG_SYNC;
  837.         devPtr->messageBuf[3] = NCR_TO_SCSI(MIN_SYNCH_PERIOD);
  838.         devPtr->messageBuf[4] = MAX_SYNCH_OFFSET;
  839.         devPtr->messageBufLen = 5;
  840.     }
  841.     break;
  842.     case SEQ_NO_CMD:
  843.     msgNum = 3;
  844.     break;
  845.     case SEQ_CMD_INCOMPLETE:
  846.     msgNum = 4;
  847.     break;
  848.     default:
  849.     msgNum = 5;
  850.     break;
  851.     }
  852.     
  853.     if (msgNum) {
  854.     ctrlPtr->regsPtr->scsi_ctrl.write.command = CR_FLSH_FIFO;
  855.     if (status == SUCCESS) {
  856.         status = FAILURE;
  857.     }
  858.     }
  859.     
  860.     return status;
  861.  
  862. } 
  863.  
  864. /*
  865.  *----------------------------------------------------------------------
  866.  *
  867.  * PerformDataXfer
  868.  *
  869.  *    Interpret data-in, data-out condition
  870.  *
  871.  * Results:
  872.  *    None.
  873.  *
  874.  * Side effects:
  875.  *    None.
  876.  *
  877.  *----------------------------------------------------------------------
  878.  */
  879. /*ARGSUSED*/
  880. static ReturnStatus
  881. PerformDataXfer(ctrlPtr, interruptReg, statusReg)
  882.     Controller      *ctrlPtr;
  883.     unsigned int    interruptReg;
  884.     unsigned int    statusReg;
  885. {
  886.     ReturnStatus status = SUCCESS;
  887.     volatile CtrlRegs    *regsPtr = ctrlPtr->regsPtr;
  888.     Device         *devPtr = ctrlPtr->devPtr;
  889.     unsigned char  fifoCnt;
  890.     int            residual;
  891.     int           amountXfered;
  892.  
  893.     if (interruptReg & IR_DISCNCT) {
  894.     printf("%s disconnected or timed out during data xfer.\n",
  895.            devPtr->handle.locationName);
  896.     return DEV_TIMEOUT;
  897.     }
  898.  
  899. #ifdef sun4c
  900.     dmaControllerActive--;
  901.     MACH_DELAY(100);
  902. #endif
  903.     residual = regsPtr->scsi_ctrl.read.xCntLo;
  904. #ifdef sun4c
  905.     MACH_DELAY(100);
  906. #endif
  907.     residual += (regsPtr->scsi_ctrl.read.xCntHi << 8);
  908.     fifoCnt = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  909.     residual += fifoCnt;
  910.     /*
  911.      * If the transfer was the maximum, 64K bytes, a 0 in the counter
  912.      * may mean that nothing was transfered...  What should I do? XXX
  913.      */
  914.  
  915.     PUTCIRCBUF(CSTR,"residual: ");
  916.     PUTCIRCBUF(CINT,(char *)(residual));
  917.     PUTCIRCBUF(CSTR,"; fifoCnt ");
  918.     PUTCIRCBUF(CINT,(char *)(fifoCnt));
  919.     PUTCIRCNULL;
  920.     regsPtr->scsi_ctrl.write.command = CR_FLSH_FIFO;
  921.  
  922.     /*
  923.      * Flush the cache on data in, since the dma put it into memory
  924.      * but didn't go through the cache.  We don't have to worry about this
  925.      * on writes, since the sparcstation has a write-through cache.
  926.      */
  927.     amountXfered = devPtr->activeBufLen - residual;
  928.     if (devPtr->lastPhase == PHASE_DATA_IN) {
  929.     FLUSH_BYTES((char *) ctrlPtr->buffer, devPtr->activeBufPtr, 
  930.             amountXfered);
  931.     }
  932.     devPtr->activeBufPtr += amountXfered;
  933.     devPtr->activeBufLen = residual;
  934.  
  935.     if (! (interruptReg & IR_BUS_SERV)) {
  936.     /* Target didn't request information transfer phase. */
  937.     printf("Didn't receive bus service signal after DMA xfer.\n");
  938.     status = FAILURE;
  939.     }
  940.  
  941.     return status;
  942.  
  943. }
  944.  
  945. /*
  946.  *----------------------------------------------------------------------
  947.  *
  948.  * PerformStatus
  949.  *
  950.  *    Interpret status condition
  951.  *
  952.  * Results:
  953.  *    None.
  954.  *
  955.  * Side effects:
  956.  *    None.
  957.  *
  958.  *----------------------------------------------------------------------
  959.  */
  960. static ReturnStatus
  961. PerformStatus(ctrlPtr, interruptReg)
  962. Controller      *ctrlPtr;
  963. unsigned int    interruptReg;
  964. {
  965.     volatile CtrlRegs    *regsPtr = ctrlPtr->regsPtr;
  966.     Device              *devPtr = ctrlPtr->devPtr;
  967.     int            numBytes;
  968.     unsigned            char message;
  969.  
  970.     devPtr->lastPhase = PHASE_STAT_MSG_IN;
  971.     /* Read bytes from FIFO. */
  972.     numBytes = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  973.     if (numBytes != 2) {
  974.     /* We didn't get both phases. */
  975.     printf("SCSIC90: Missing message byte after status phase byte.\n");
  976.     return(FAILURE);
  977.     }
  978.     devPtr->commandStatus = regsPtr->scsi_ctrl.read.FIFO;
  979.     devPtr->commandStatus &= SCSI_STATUS_MASK;
  980.     message = regsPtr->scsi_ctrl.read.FIFO;
  981.     if (! (interruptReg & IR_FUNC_COMP)) {
  982.     printf("SCSIC90: Command didn't complete.\n");
  983.     return(FAILURE);
  984.     }
  985.  
  986.     if (message != SCSI_COMMAND_COMPLETE) {
  987.     printf("SCSIC90: Expecting cmd_complete msg from %s, got ",
  988.            ctrlPtr->devPtr->handle.locationName);
  989.     PrintMsg((unsigned int) message);
  990.     return(FAILURE);
  991.     }
  992.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  993.     
  994.     return SUCCESS;
  995. }
  996.  
  997. /*
  998.  *----------------------------------------------------------------------
  999.  *
  1000.  * PerformMsgIn
  1001.  *
  1002.  *    Interpret msg_in condition
  1003.  *
  1004.  * Results:
  1005.  *    None.
  1006.  *
  1007.  * Side effects:
  1008.  *    None.
  1009.  *
  1010.  *----------------------------------------------------------------------
  1011.  */
  1012. static ReturnStatus
  1013. PerformMsgIn(ctrlPtr)
  1014. Controller *ctrlPtr;
  1015. {
  1016.     ReturnStatus status = SUCCESS;
  1017.     Device *devPtr = ctrlPtr->devPtr;
  1018.     volatile CtrlRegs *regsPtr = ctrlPtr->regsPtr;
  1019.     unsigned char message;
  1020.  
  1021.     message = regsPtr->scsi_ctrl.read.FIFO;
  1022.  
  1023.     PUTCIRCBUF(CSTR,"msg in: ");
  1024.     PUTCIRCBUF(CBYTE, (char *)message);
  1025.     PUTCIRCNULL;
  1026.  
  1027.     if (devPtr->msgFlag & STARTEXTENDEDMSG) { 
  1028.     status = PerformExtendedMsgIn(ctrlPtr,(unsigned int)message);
  1029.     return status;
  1030.     }
  1031.  
  1032.     switch(message) {
  1033.     case SCSI_COMMAND_COMPLETE:
  1034.     /* this is handled in that stat_msg_in phase */
  1035.     printf("not expecting command_complete msg.\n");
  1036.     status = FAILURE;
  1037.     break;
  1038.     case SCSI_DISCONNECT:
  1039.     devPtr->lastPhase = PHASE_RDY_DISCON;
  1040.     break;
  1041.     case SCSI_SAVE_DATA_POINTER:
  1042.     /* No need to save anything since we keep the current
  1043.      * data ptr in activeBufPtr anyway. */
  1044.     devPtr->lastPhase = PHASE_BUS_FREE;
  1045.     PUTCIRCBUF(CSTR,"save: ptr ");
  1046.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufPtr);
  1047.     PUTCIRCBUF(CSTR,"; len ");
  1048.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufLen);
  1049.     PUTCIRCNULL;
  1050.     break;
  1051.     case SCSI_RESTORE_POINTERS:
  1052.     /* No need to restore anything, since we keep the
  1053.      * current data ptr in activeBufPtr anyway. */
  1054.     devPtr->lastPhase = PHASE_BUS_FREE;
  1055.     PUTCIRCBUF(CSTR,"restore: ptr ");
  1056.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufPtr);
  1057.     PUTCIRCBUF(CSTR,"; len ");
  1058.     PUTCIRCBUF(CINT, (char *)devPtr->activeBufLen);
  1059.     PUTCIRCNULL;
  1060.     break;
  1061.     case SCSI_IDENTIFY:
  1062.     devPtr->lastPhase = PHASE_BUS_FREE;
  1063.     break;
  1064.     case SCSI_EXTENDED_MESSAGE:
  1065.     if (devPtr->msgFlag & ENABLEEXTENDEDMSG) {
  1066.         devPtr->msgFlag |= STARTEXTENDEDMSG;
  1067.         status = PerformExtendedMsgIn(ctrlPtr,(unsigned int)message);
  1068.         return status;
  1069.     } else {
  1070.         devPtr->lastPhase = PHASE_MSG_OUT;
  1071.         devPtr->messageBuf[0] = SCSI_MESSAGE_REJECT;
  1072.         devPtr->messageBufLen = 1;
  1073.         regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1074.     }
  1075.     break;
  1076.     case SCSI_MESSAGE_REJECT:
  1077.     /* kill any synchronous agreement in effect */
  1078.     devPtr->synchPeriod = MIN_SYNCH_PERIOD;
  1079.     devPtr->synchOffset = 0;
  1080.     devPtr->lastPhase = PHASE_BUS_FREE;
  1081.     devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1082.     break;
  1083.     default:
  1084.     PUTCIRCBUF(CSTR,"Msg-in: unknown msg");
  1085.     PUTCIRCNULL;
  1086.     printf("SCSIC90: Couldn't handle msg type: 0x%02x\n",message);
  1087.     regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1088.     devPtr->lastPhase = PHASE_BUS_FREE;
  1089.     break;
  1090.     }
  1091.  
  1092.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  1093.  
  1094.     return status;
  1095.  
  1096. } /* PerformMsgIn */
  1097.  
  1098. /*
  1099.  *----------------------------------------------------------------------
  1100.  *
  1101.  * PerformExtendedMsgIn
  1102.  *
  1103.  *    Interpret extended msg_in condition
  1104.  *
  1105.  * Results:
  1106.  *    status.
  1107.  *
  1108.  * Side effects:
  1109.  *      Sets the values for synchronous xfer in the device structure.
  1110.  *
  1111.  *    We get the bytes of the extended msg 1 at a time.
  1112.  *      Format: extended msg indicator : 0x01 
  1113.  *                       msg length    : 0x?? 
  1114.  *                       msg code      : 0x03 (we only do 1 type) 
  1115.  *                       msg param1    : 0x?? (should be synch_period)
  1116.  *                       msg param2    : 0x?? (should be synch_offset)
  1117.  *
  1118.  *----------------------------------------------------------------------
  1119.  */
  1120. static ReturnStatus
  1121. PerformExtendedMsgIn(ctrlPtr, message)
  1122. Controller *ctrlPtr;
  1123. unsigned int message;
  1124. {
  1125.     ReturnStatus status = SUCCESS;
  1126.     Device *devPtr      = ctrlPtr->devPtr;
  1127.     volatile CtrlRegs *regsPtr = ctrlPtr->regsPtr;
  1128.     int len             = devPtr->messageBufLen;
  1129.     unsigned char periodInClks;
  1130.     unsigned char period;
  1131.     unsigned char offset;
  1132.     int i;
  1133.  
  1134.     devPtr->messageBuf[len] = message;
  1135.     devPtr->messageBufLen++;
  1136.  
  1137.     switch(len) {
  1138.     case 0: /* extended msg code 0x01 */
  1139.     devPtr->lastPhase = PHASE_BUS_FREE;
  1140.     break;
  1141.     case 1: /* msg length. i.e. # bytes to follow this one */
  1142.     devPtr->lastPhase = PHASE_BUS_FREE;
  1143.     break;
  1144.     case 2: /* extended msg code */
  1145.     if ((message != SCSI_EXTENDED_MSG_SYNC) ||
  1146.         (devPtr->messageBuf[1] != 3)) {
  1147.         PUTCIRCBUF(CSTR,"Msg-in: bad xtend msg: ");
  1148.         PUTCIRCBUF(CBYTE,(char *)(message));
  1149.         PUTCIRCBUF(CSTR,"; len ");
  1150.         PUTCIRCBUF(CBYTE,(char *)(devPtr->messageBuf[1]));
  1151.         PUTCIRCNULL;
  1152.         panic("bad xtend msg");
  1153.         devPtr->messageBuf[0] = SCSI_MESSAGE_REJECT;
  1154.         devPtr->messageBufLen = 1;
  1155.         regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1156.         devPtr->lastPhase = PHASE_MSG_OUT;
  1157.         devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1158.     } else {
  1159.         devPtr->lastPhase = PHASE_BUS_FREE;
  1160.     }
  1161.     break;
  1162.     case 3: /* synch_period */
  1163.     devPtr->lastPhase = PHASE_BUS_FREE;
  1164.     break;
  1165.     case 4: /* synch_offset */
  1166.     /* 
  1167.      * Now we have both the period and the offset.
  1168.      */
  1169.     period = devPtr->messageBuf[3];
  1170.     offset = devPtr->messageBuf[4];
  1171.     periodInClks = SCSI_TO_NCR(period);
  1172.     /* if values are acceptable, install them else negotiate */
  1173.     if ((periodInClks >= MIN_SYNCH_PERIOD) &&
  1174.         (offset <= MAX_SYNCH_OFFSET)) {
  1175.         PUTCIRCBUF(CSTR,"accept per: ");
  1176.         PUTCIRCBUF(CBYTE,(char *)period);
  1177.         PUTCIRCBUF(CSTR,"; per clk ");
  1178.         PUTCIRCBUF(CBYTE,(char *)periodInClks);
  1179.         PUTCIRCBUF(CSTR,"; off ");
  1180.         PUTCIRCBUF(CBYTE,(char *)offset);
  1181.         PUTCIRCNULL;
  1182.         devPtr->synchPeriod = periodInClks; 
  1183.         devPtr->synchOffset = offset;
  1184.         devPtr->lastPhase = PHASE_BUS_FREE;
  1185.         devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1186.     } else {
  1187.         if (periodInClks < devPtr->synchPeriod) {
  1188.         devPtr->messageBuf[3] = NCR_TO_SCSI(MIN_SYNCH_PERIOD);
  1189.         }
  1190.         if (offset > devPtr->synchOffset) {
  1191.         devPtr->messageBuf[4] = MAX_SYNCH_OFFSET;
  1192.         }
  1193.         PUTCIRCBUF(CSTR,"negotiate per: ");
  1194.         PUTCIRCBUF(CBYTE,(char *)(devPtr->messageBuf[3]));
  1195.         PUTCIRCBUF(CSTR,"; off ");
  1196.         PUTCIRCBUF(CBYTE,(char *)(devPtr->messageBuf[4]));
  1197.         PUTCIRCNULL;
  1198.         regsPtr->scsi_ctrl.write.command = CR_SET_ATN;
  1199.         devPtr->lastPhase = PHASE_MSG_OUT;
  1200.         devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1201.     }
  1202.     break;
  1203.     default:
  1204.     printf("SCSIC90: xmsg case error\n");
  1205.     devPtr->msgFlag &= ~STARTEXTENDEDMSG;
  1206.     status = FALSE;
  1207.     break;
  1208.     }
  1209.     PUTCIRCBUF(CSTR,"Xmsg-in: accept msg");
  1210.     len = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  1211.     PUTCIRCBUF(CSTR,"; FIFO:");
  1212.     for(i=0;i<len;i++) {
  1213.     circBuf[circHead] = ' ';
  1214.     circHead = (circHead + 1) % CIRCBUFLEN;
  1215.     offset = regsPtr->scsi_ctrl.read.FIFO;
  1216.     PUTCIRCBUF(CBYTE, (char *)offset);
  1217.     }
  1218.     PUTCIRCBUF(CSTR,"; mbuf:");
  1219.     for(i=0;i<devPtr->messageBufLen;i++) {
  1220.     circBuf[circHead] = ' ';
  1221.     circHead = (circHead + 1) % CIRCBUFLEN;
  1222.     PUTCIRCBUF(CBYTE, (char *)(devPtr->messageBuf[i]));
  1223.     }
  1224.     PUTCIRCNULL;
  1225.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  1226.     return status;
  1227. } 
  1228.  
  1229. /*
  1230.  *----------------------------------------------------------------------
  1231.  *
  1232.  * PerformReselect
  1233.  *
  1234.  *    Reconnect a logical unit
  1235.  *
  1236.  * Results:
  1237.  *    None.
  1238.  *
  1239.  * Side effects:
  1240.  *    None.
  1241.  *
  1242.  *----------------------------------------------------------------------
  1243.  */
  1244. static ReturnStatus
  1245. PerformReselect(ctrlPtr, interruptReg)
  1246. Controller      *ctrlPtr;
  1247. unsigned int    interruptReg;
  1248. {
  1249.     volatile CtrlRegs *regsPtr = ctrlPtr->regsPtr;
  1250.     Device            *devPtr;
  1251.     unsigned char     target;
  1252.     unsigned char     ourID;
  1253.     unsigned char     message;
  1254.     int               fifoCnt,i;
  1255.  
  1256.     /* The ID of the target which is requesting reselection comes over 
  1257.      * the bus encoded, not 0-7.  The encoding is the logical OR of 
  1258.      * two bytes: one with the i'th bit set (for target #i) and
  1259.      * one with the host's bit set (usually #7). Unfortunately,
  1260.      * the host's ID is kindly provided to us in binary so we perform
  1261.      * a little transformation...
  1262.      */
  1263.     target = regsPtr->scsi_ctrl.read.FIFO;
  1264.     ourID = regsPtr->scsi_ctrl.read.config1 & C1_BUS_ID;
  1265.     ourID = ~(1 << ourID);
  1266.  
  1267.     switch(target & ourID) {
  1268.     case 0x01:
  1269.     target = 0;
  1270.     break;
  1271.     case 0x02:
  1272.     target = 1;
  1273.     break;
  1274.     case 0x04:
  1275.     target = 2;
  1276.     break;
  1277.     case 0x08:
  1278.     target = 3;
  1279.     break;
  1280.     case 0x10:
  1281.     target = 4;
  1282.     break;
  1283.     case 0x20:
  1284.     target = 5;
  1285.     break;
  1286.     case 0x40:
  1287.     target = 6;
  1288.     break;
  1289.     case 0x80:
  1290.     target = 7;
  1291.     break;
  1292.     default:
  1293.     printf("SCSIC90: couldn't decode target ID 0x%02x\n", target);
  1294.     return FAILURE;
  1295.     }
  1296.  
  1297.     message = regsPtr->scsi_ctrl.read.FIFO;    
  1298.  
  1299.     if (!(message & SCSI_IDENTIFY)) {
  1300.     printf("SCSIC90: Expected Identify msg after reselect, got 0x%02x.\n",
  1301.            message);
  1302.     return FAILURE;
  1303.     }
  1304.     message &= SCSI_IDENT_LUN_MASK;
  1305.  
  1306.     devPtr = ctrlPtr->devicePtr[target][message];
  1307.  
  1308.     fifoCnt = regsPtr->scsi_ctrl.read.FIFOFlags & FIFO_BYTES_MASK;
  1309.     PUTCIRCBUF(CSTR,"resel: targ ");
  1310.     PUTCIRCBUF(CBYTE, (char *)target);
  1311.     PUTCIRCBUF(CSTR,"; lun ");
  1312.     PUTCIRCBUF(CBYTE, (char *)message);
  1313.     ourID = regsPtr->scsi_ctrl.read.command;
  1314.     PUTCIRCBUF(CSTR,"; cmdreg:");
  1315.     PUTCIRCBUF(CBYTE,(char *)ourID);
  1316.     PUTCIRCBUF(CSTR,"; FIFO:");
  1317.     for(i=0;i<fifoCnt;i++) {
  1318.     circBuf[circHead] = ' ';
  1319.     circHead = (circHead + 1) % CIRCBUFLEN;
  1320.     ourID = regsPtr->scsi_ctrl.read.FIFO;
  1321.     PUTCIRCBUF(CBYTE, (char *)ourID);
  1322.     }
  1323.     PUTCIRCNULL;
  1324.  
  1325.     if (IS_DEV_FREE(devPtr)) {
  1326.     panic("resel: device is free.\n");
  1327.     }
  1328.  
  1329.     /*
  1330.      * It's possible for the reselection interrupt to occur just
  1331.      * when we were sending a new command.  Three cases:
  1332.      *  1) Interrupt happened before loading any cmd bytes.
  1333.      *     Only indication is that controller is busy.
  1334.      *  2) Interrupt happened before the send; part of the
  1335.      *     cmd in the fifo.
  1336.      *  3) Interrupt happened during the arbitration/selection
  1337.      *     phases of the send; the bus_serv bit will be set.
  1338.      * Note that the 53C90 doesn't handle this situation quite
  1339.      * the same as the later 53C94, 53C95 chips. The older chip
  1340.      * accepts cmd bytes after it shouldn't so there may be bytes
  1341.      * in the FIFO now that should be here. See the manual.
  1342.      */
  1343.  
  1344.  
  1345.     /* An restore_data_ pointer cmd is implied by a reselect
  1346.      * but we don't need to do anything */
  1347.     regsPtr->scsi_ctrl.write.command = CR_MSG_ACCPT;
  1348.  
  1349.     if (!(IS_CTRL_FREE(ctrlPtr)) ||
  1350.     (interruptReg & IR_BUS_SERV) ||
  1351.     (fifoCnt > 0)) {
  1352.     PUTCIRCBUF(CSTR,"resel: save dev ");
  1353.     PUTCIRCBUF(CINT, (char *)ctrlPtr->devPtr);
  1354.     PUTCIRCBUF(CSTR," cmd ");
  1355.     PUTCIRCBUF(CINT, (char *)ctrlPtr->devPtr->scsiCmdPtr);
  1356.     PUTCIRCNULL;
  1357.     ctrlPtr->interruptDevPtr = ctrlPtr->devPtr;
  1358.     regsPtr->scsi_ctrl.write.command = CR_FLSH_FIFO;
  1359.     }
  1360.  
  1361.     SET_CTRL_BUSY(ctrlPtr,devPtr);
  1362.  
  1363.     return SUCCESS;
  1364. }
  1365.  
  1366. /*
  1367.  *----------------------------------------------------------------------
  1368.  *
  1369.  * ReleaseProc --
  1370.  *
  1371.  *    Device release proc for controller.
  1372.  *
  1373.  * Results:
  1374.  *    None.
  1375.  *
  1376.  * Side effects:
  1377.  *    None.
  1378.  *
  1379.  *----------------------------------------------------------------------
  1380.  */
  1381. /*ARGSUSED*/
  1382. static ReturnStatus
  1383. ReleaseProc(scsiDevicePtr)
  1384.     ScsiDevice    *scsiDevicePtr;
  1385. {
  1386.     return SUCCESS;
  1387. }
  1388.  
  1389.  
  1390. /*
  1391.  *----------------------------------------------------------------------
  1392.  *
  1393.  * DevSCSIC90AttachDevice --
  1394.  *
  1395.  *    Attach a SCSI device using the Sun SCSIC90 HBA. 
  1396.  *
  1397.  * Results:
  1398.  *    None.
  1399.  *
  1400.  * Side effects:
  1401.  *    None.
  1402.  *
  1403.  *----------------------------------------------------------------------
  1404.  */
  1405.  
  1406. ScsiDevice   *
  1407. DevSCSIC90AttachDevice(devicePtr, insertProc)
  1408.     Fs_Device    *devicePtr;     /* Device to attach. */
  1409.     void    (*insertProc)(); /* Queue insert procedure. */
  1410. {
  1411.     Device *devPtr;
  1412.     Controller    *ctrlPtr;
  1413.     char   tmpBuffer[512];
  1414.     int       length;
  1415.     int       ctrlNum;
  1416.     int       targetID, lun;
  1417.  
  1418.     /*
  1419.      * First find the SCSIC90 controller this device is on.
  1420.      */
  1421.     ctrlNum = SCSI_HBA_NUMBER(devicePtr);
  1422.     if ((ctrlNum > MAX_SCSIC90_CTRLS) ||
  1423.     (Controllers[ctrlNum] == (Controller *) 0)) { 
  1424.     return (ScsiDevice  *) NIL;
  1425.     } 
  1426.     ctrlPtr = Controllers[ctrlNum];
  1427.     targetID = SCSI_TARGET_ID(devicePtr);
  1428.     lun = SCSI_LUN(devicePtr);
  1429.     /*
  1430.      * Allocate a device structure for the device and fill in the
  1431.      * handle part. This must be created before we grap the MASTER_LOCK.
  1432.      */
  1433.     devPtr = (Device *) malloc(sizeof(Device)); 
  1434.     bzero((char *) devPtr, sizeof(Device));
  1435.     devPtr->handle.devQueue = Dev_QueueCreate(ctrlPtr->devQueues,
  1436.                           (1<<targetID),
  1437.                           insertProc,
  1438.                           (ClientData) devPtr);
  1439.     devPtr->handle.locationName = "Unknown";
  1440.     devPtr->handle.LUN = lun;
  1441.     devPtr->handle.releaseProc = ReleaseProc;
  1442.     devPtr->handle.maxTransferSize = MAX_TRANSFER_SIZE;
  1443.     devPtr->targetID = targetID;
  1444.     devPtr->ctrlPtr = ctrlPtr;
  1445.     devPtr->synchPeriod = 0;
  1446.     devPtr->synchOffset = 0;
  1447.     devPtr->msgFlag = 0;
  1448.     MASTER_LOCK(&(ctrlPtr->mutex));
  1449.     /*
  1450.      * A device pointer of zero means that targetID/LUN 
  1451.      * conflicts with that of the HBA. A NIL means the
  1452.      * device hasn't been attached yet.
  1453.      */
  1454.     if (ctrlPtr->devicePtr[targetID][lun] == (Device *) 0) {
  1455.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  1456.     (void) Dev_QueueDestroy(devPtr->handle.devQueue);
  1457.     free((char *) devPtr);
  1458.     return (ScsiDevice *) NIL;
  1459.     }
  1460.     if (ctrlPtr->devicePtr[targetID][lun] != (Device *) NIL) {
  1461.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  1462.     (void) Dev_QueueDestroy(devPtr->handle.devQueue);
  1463.     free((char *) devPtr);
  1464.     return (ScsiDevice *) (ctrlPtr->devicePtr[targetID][lun]);
  1465.     }
  1466.     SET_DEV_FREE(devPtr);
  1467.     ctrlPtr->devicePtr[targetID][lun] = devPtr;
  1468.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  1469.     (void) sprintf(tmpBuffer, "%s Target %d LUN %d", ctrlPtr->name, 
  1470.             devPtr->targetID, devPtr->handle.LUN);
  1471.     length = strlen(tmpBuffer);
  1472.     devPtr->handle.locationName = (char *) strcpy(malloc(length+1),tmpBuffer);
  1473.  
  1474.     if (devSCSIC90Debug > 3) {
  1475.     printf("devSCSIC90Attach: attached device %s.\n", tmpBuffer);
  1476.     }
  1477.  
  1478.     return (ScsiDevice *) devPtr;
  1479. }
  1480.  
  1481.  
  1482. /*
  1483.  *----------------------------------------------------------------------
  1484.  *
  1485.  * PrintMsg --
  1486.  *
  1487.  *    Print out the asci string for a scsi msg.
  1488.  *
  1489.  * Results:
  1490.  *    None.
  1491.  *
  1492.  * Side effects:
  1493.  *    None.
  1494.  *
  1495.  *----------------------------------------------------------------------
  1496.  */
  1497. static void
  1498. PrintMsg(msg)
  1499.     unsigned int msg;
  1500. {
  1501.  
  1502.     if (msg & SCSI_IDENTIFY) {
  1503.     if (msg & SCSI_DIS_REC_IDENTIFY) {
  1504.         printf("dis_rec_identify (LUN 0x%02x) msg.\n",
  1505.            (int)(msg & SCSI_IDENT_LUN_MASK));
  1506.     } else {
  1507.         printf("identify (LUN 0x%02x) msg.\n",
  1508.            (int)(msg & SCSI_IDENT_LUN_MASK));
  1509.     }
  1510.     return;
  1511.     } 
  1512.  
  1513.     switch (msg) {
  1514.     case SCSI_COMMAND_COMPLETE:
  1515.     printf("command_complete msg.\n");
  1516.     break;
  1517.     case SCSI_SAVE_DATA_POINTER:
  1518.     printf("save_data_ptr msg.\n");
  1519.     break;
  1520.     case SCSI_RESTORE_POINTERS:
  1521.     printf("restore_ptrs msg.\n");
  1522.     break;
  1523.     case SCSI_DISCONNECT:
  1524.     printf("disconnect msg.\n");
  1525.     break;
  1526.     case SCSI_ABORT:
  1527.     printf("abort msg.\n");
  1528.     break;
  1529.     case SCSI_MESSAGE_REJECT:
  1530.     printf("msg_reject msg.\n");
  1531.     break;
  1532.     case SCSI_NO_OP:
  1533.     printf("no_op msg.\n");
  1534.     break;
  1535.     case SCSI_MESSAGE_PARITY_ERROR:
  1536.     printf("msg_parity msg.\n");
  1537.     break;
  1538.     case SCSI_BUS_RESET:
  1539.     printf("bus_reset msg.\n");
  1540.     break;
  1541.     default:
  1542.     printf("unknown msg %d.\n", msg);
  1543.     break;
  1544.     }
  1545.  
  1546.     return;
  1547. }
  1548.  
  1549. #ifndef lint
  1550.  
  1551. /*
  1552.  *----------------------------------------------------------------------
  1553.  *
  1554.  * PrintPhase --
  1555.  *
  1556.  *    Print out the asci string for a scsi phase.
  1557.  *
  1558.  * Results:
  1559.  *    None.
  1560.  *
  1561.  * Side effects:
  1562.  *    None.
  1563.  *
  1564.  *----------------------------------------------------------------------
  1565.  */
  1566. static void
  1567. PrintPhase(phase)
  1568.     unsigned int    phase;
  1569. {
  1570.     
  1571.     switch (phase) {
  1572.     case SR_DATA_OUT:
  1573.     printf("data out phase.\n");
  1574.     break;
  1575.     case SR_DATA_IN:
  1576.     printf("data in phase.\n");
  1577.     break;
  1578.     case SR_COMMAND:
  1579.     printf("command phase.\n");
  1580.     break;
  1581.     case SR_STATUS:
  1582.     printf("status phase.\n");
  1583.     break;
  1584.     case SR_MSG_OUT:
  1585.     printf("msg out phase.\n");
  1586.     break;
  1587.     case SR_MSG_IN:
  1588.     printf("msg in phase.\n");
  1589.     break;
  1590.     default:
  1591.     printf("unknown phase %d.\n", phase);
  1592.     break;
  1593.     }
  1594.  
  1595.     return;
  1596. }
  1597.  
  1598. /*
  1599.  *----------------------------------------------------------------------
  1600.  *
  1601.  * PrintLastPhase --
  1602.  *
  1603.  *    Print out the asci string for the last scsi phase we were in.
  1604.  *
  1605.  * Results:
  1606.  *    None.
  1607.  *
  1608.  * Side effects:
  1609.  *    None.
  1610.  *
  1611.  *----------------------------------------------------------------------
  1612.  */
  1613. static void
  1614. PrintLastPhase(phase)
  1615.     unsigned int    phase;
  1616. {
  1617.     switch (phase) {
  1618.     case PHASE_BUS_FREE:
  1619.     printf("bus free phase.\n");
  1620.     break;
  1621.     case PHASE_SELECTION:
  1622.     printf("selection phase.\n");
  1623.     break;
  1624.     case PHASE_DATA_OUT:
  1625.     printf("data out phase.\n");
  1626.     break;
  1627.     case PHASE_DATA_IN:
  1628.     printf("data in phase.\n");
  1629.     break;
  1630.     case PHASE_STATUS:
  1631.     printf("status phase.\n");
  1632.     break;
  1633.     case PHASE_MSG_IN:
  1634.     printf("msg in phase.\n");
  1635.     break;
  1636.     case PHASE_STAT_MSG_IN:
  1637.     printf("stat_msg in phase.\n");
  1638.     break;
  1639.     case PHASE_RDY_DISCON:
  1640.     printf("rdy_discon phase.\n");
  1641.     break;
  1642.     default:
  1643.     printf("unknown phase %d.\n", phase);
  1644.     break;
  1645.     }
  1646.  
  1647.     return;
  1648. }
  1649.  
  1650. /*
  1651.  *----------------------------------------------------------------------
  1652.  *
  1653.  * PrintRegs --
  1654.  *
  1655.  *    Print out the interesting registers.  This could be a macro but
  1656.  *    then it couldn't be called from kdbx.  This routine is necessary
  1657.  *    because kdbx doesn't print all the character values properly.
  1658.  *
  1659.  * Results:
  1660.  *    None.
  1661.  *
  1662.  * Side effects:
  1663.  *    Data is displayed on the console or to the debugger.
  1664.  *
  1665.  *----------------------------------------------------------------------
  1666.  */
  1667. static void
  1668. PrintRegs(regsPtr)
  1669.     register volatile CtrlRegs *regsPtr;
  1670. {
  1671.  
  1672.     printf("Won't print interrupt register since that would clear it.\n");
  1673.     printf("xCntLow: 0x%x, xCntHi: 0x%x, FIFO: 0x%x, command: 0x%x,\n",
  1674.         regsPtr->scsi_ctrl.read.xCntLo,
  1675.         regsPtr->scsi_ctrl.read.xCntHi,
  1676.         regsPtr->scsi_ctrl.read.FIFO,
  1677.         regsPtr->scsi_ctrl.read.command);
  1678.     printf("status: 0x%x, sequence: 0x%x, FIFOFlags: 0x%x, config1: 0x%x,\n",
  1679.         regsPtr->scsi_ctrl.read.status,
  1680.         regsPtr->scsi_ctrl.read.sequence,
  1681.         regsPtr->scsi_ctrl.read.FIFOFlags,
  1682.         regsPtr->scsi_ctrl.read.config1);
  1683.     printf("config2: 0x%x, config3: 0x%x\n",
  1684.         regsPtr->scsi_ctrl.read.config2,
  1685.         regsPtr->scsi_ctrl.read.config3);
  1686.  
  1687.     return;
  1688. }
  1689. #endif /* LINT */
  1690.  
  1691. /*
  1692.  *----------------------------------------------------------------------
  1693.  *
  1694.  *  SpecialSenseProc --
  1695.  *
  1696.  *    Special function used for HBA generated REQUEST SENSE. A SCSI
  1697.  *    command request with this function as a call back proc will
  1698.  *    be processed by routine RequestDone as a result of a 
  1699.  *    REQUEST SENSE. This routine is never called.
  1700.  *
  1701.  * Results:
  1702.  *    None.
  1703.  *
  1704.  * Side effects:
  1705.  *    None.
  1706.  *
  1707.  *----------------------------------------------------------------------
  1708.  */
  1709. /*ARGSUSED*/
  1710. static int
  1711. SpecialSenseProc(scsiCmdPtr, status, statusByte, byteCount, senseLength,
  1712.          senseDataPtr)
  1713.     ScsiCmd        *scsiCmdPtr;
  1714.     ReturnStatus    status;
  1715.     unsigned char    statusByte;
  1716.     int            byteCount;
  1717.     int            senseLength;
  1718.     Address        senseDataPtr;
  1719. {
  1720.     return 0;
  1721. }
  1722.  
  1723.  
  1724. /*
  1725.  *----------------------------------------------------------------------
  1726.  *
  1727.  * Dev_ChangeScsiDebugLevel --
  1728.  *
  1729.  *    Change the level of debugging info for this scsi driver.
  1730.  *
  1731.  * Results:
  1732.  *    None.
  1733.  *
  1734.  * Side effects:
  1735.  *    A larger or lesser number of messages will be printed out.
  1736.  *
  1737.  *----------------------------------------------------------------------
  1738.  */
  1739. void
  1740. Dev_ChangeScsiDebugLevel(level)
  1741.     int    level;
  1742. {
  1743.     
  1744.     printf("Changing scsi debug level: was %d, ", devSCSIC90Debug);
  1745.     devSCSIC90Debug = level;
  1746.     printf("and is now %d.\n", devSCSIC90Debug);
  1747.  
  1748.     return;
  1749. }
  1750.  
  1751.  
  1752. /*
  1753.  *----------------------------------------------------------------------
  1754.  *
  1755.  * PutCircBuf
  1756.  *
  1757.  *    Stuff data into the circular log buffer
  1758.  *
  1759.  * Results:
  1760.  *    None.
  1761.  *
  1762.  * Side effects:
  1763.  *      None.
  1764.  *
  1765.  *----------------------------------------------------------------------
  1766.  */
  1767. static void
  1768. PutCircBuf(type, object)
  1769. int type;
  1770. char *object;
  1771. {
  1772.     int num = (int)object;
  1773.  
  1774.     switch(type) {
  1775.     case CSTR:
  1776.     while(*object) {
  1777.         circBuf[circHead] = *object++;
  1778.         circHead = (circHead + 1) % CIRCBUFLEN;
  1779.     }
  1780.     break;
  1781.     case CBYTE:
  1782.     circBuf[circHead] = CVTHEX(num,4);
  1783.     circHead = (circHead + 1) % CIRCBUFLEN;
  1784.     circBuf[circHead] = CVTHEX(num,0);
  1785.     circHead = (circHead + 1) % CIRCBUFLEN;
  1786.     break;
  1787.     case CINT:
  1788.     circBuf[circHead] = CVTHEX(num,28); 
  1789.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1790.     circBuf[circHead] = CVTHEX(num,24); 
  1791.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1792.     circBuf[circHead] = CVTHEX(num,20); 
  1793.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1794.     circBuf[circHead] = CVTHEX(num,16); 
  1795.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1796.     circBuf[circHead] = CVTHEX(num,12); 
  1797.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1798.     circBuf[circHead] = CVTHEX(num,8); 
  1799.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1800.     circBuf[circHead] = CVTHEX(num,4); 
  1801.     circHead = (circHead + 1) % CIRCBUFLEN; 
  1802.     circBuf[circHead] = CVTHEX(num,0); 
  1803.     circHead = (circHead + 1) % CIRCBUFLEN;
  1804.     break;
  1805.     default:
  1806.     panic("PutCircBuf: unknown type\n");
  1807.     break;
  1808.     }
  1809. }
  1810.  
  1811.